package com.study.testSpringBoot.concurrent;

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;

import org.springframework.stereotype.Component;

/**
 * 使用ConcurrentHashMap的数据模型
 * 使用不完全自旋锁，只有读数据时会有会锁上，并发写时没有锁，导致数据写入模型中时有覆盖
 * 并发写时也加上自旋锁，还是不能解决问题，应该时有并发线程同时获取到锁，写入了重复的数据
 */
@Component
public class DataModel {

	private ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<String, Integer>();
	
	private volatile boolean flag = true;
	
	private AtomicInteger result = new AtomicInteger(0);
	
	/**
	 * 使用ConcurrentHashMap生产数据，这种方式会有数据丢失
	 * @param key
	 */
	public void addData(String key) {
		while(!flag) {
			
		}
		flag = false;
//		result.incrementAndGet();
//		System.out.println("===当前生产："+result.get());
		int num = 1;
		if(map.containsKey(key)) {
			num = map.get(key) + 1;
		}
		map.put(key, num);
		flag = true;
	}
	
	public Map<String,Integer> getAndDelData() {
		flag = false;
		Map<String,Integer> m = new HashMap<>();
//		Integer num = map.get(key);
//		m.put(key, num);
//		map.remove(key);
		Set<Entry<String,Integer>> set = map.entrySet();
		for(Entry<String,Integer> entry : set) {
			m.put(entry.getKey(), entry.getValue());
		}
		map.clear();
		flag = true;
		return m;
	}
	
}
